{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Understanding Deep Deterministic Policy Gradient (DDPG): A Complete Guide\n",
    "\n",
    "# Table of Contents\n",
    "\n",
    "- [Introduction](#introduction)\n",
    "- [What is DDPG?](#what-is-ddpg)\n",
    "  - [Key Ideas: Deterministic Policy & Off-Policy Learning](#key-ideas)\n",
    "- [Where and How DDPG is Used](#where-and-how-ddpg-is-used)\n",
    "- [Mathematical Foundation of DDPG](#mathematical-foundation-of-ddpg)\n",
    "  - [Actor-Critic Framework Recap](#actor-critic-framework-recap)\n",
    "  - [Deterministic Policy Gradient Theorem](#deterministic-policy-gradient-theorem)\n",
    "  - [Critic (Q-Network) Update](#critic-q-network-update)\n",
    "  - [Actor (Policy Network) Update](#actor-policy-network-update)\n",
    "  - [Target Networks and Soft Updates](#target-networks-and-soft-updates)\n",
    "  - [Exploration Noise](#exploration-noise)\n",
    "- [Step-by-Step Explanation of DDPG](#step-by-step-explanation-of-ddpg)\n",
    "- [Key Components of DDPG](#key-components-of-ddpg)\n",
    "  - [Actor Network (Deterministic Policy)](#actor-network-deterministic-policy)\n",
    "  - [Critic Network (Q-Value Function)](#critic-network-q-value-function)\n",
    "  - [Target Actor & Target Critic Networks](#target-actor--target-critic-networks)\n",
    "  - [Replay Buffer](#replay-buffer)\n",
    "  - [Exploration Noise Process](#exploration-noise-process)\n",
    "  - [Soft Target Updates](#soft-target-updates)\n",
    "  - [Hyperparameters](#hyperparameters)\n",
    "- [Practical Example: Pendulum Environment](#practical-example-pendulum-environment)\n",
    "  - [Why Pendulum? (Continuous Actions)](#why-pendulum-continuous-actions)\n",
    "- [Setting up the Environment](#setting-up-the-environment)\n",
    "- [Creating the Continuous Environment (Gymnasium)](#creating-the-continuous-environment-gymnasium)\n",
    "- [Implementing the DDPG Algorithm](#implementing-the-ddpg-algorithm)\n",
    "  - [Defining the Actor Network](#defining-the-actor-network)\n",
    "  - [Defining the Critic Network](#defining-the-critic-network)\n",
    "  - [Defining the Replay Memory](#defining-the-replay-memory)\n",
    "  - [Defining the Exploration Noise](#defining-the-exploration-noise)\n",
    "  - [Soft Update Function](#soft-update-function)\n",
    "  - [The DDPG Update Step](#the-ddpg-update-step)\n",
    "- [Running the DDPG Algorithm](#running-the-ddpg-algorithm)\n",
    "  - [Hyperparameter Setup](#hyperparameter-setup)\n",
    "  - [Initialization](#initialization)\n",
    "  - [Training Loop](#training-loop)\n",
    "- [Visualizing the Learning Process](#visualizing-the-learning-process)\n",
    "- [Analyzing the Learned Policy (Testing)](#analyzing-the-learned-policy-testing)\n",
    "- [Common Challenges and Solutions in DDPG](#common-challenges-and-solutions-in-ddpg)\n",
    "- [Conclusion](#conclusion)\n",
    "\n",
    "## Introduction\n",
    "\n",
    "Deep Deterministic Policy Gradient (DDPG) is an **off-policy actor-critic** algorithm designed specifically for environments with **continuous action spaces**. It combines ideas from Deep Q-Networks (DQN) like replay buffers and target networks with the actor-critic framework and adapts policy gradients for deterministic policies. This makes it a powerful tool for tasks like robotic control and simulated physics environments where actions are real-valued.\n",
    "\n",
    "## What is DDPG?\n",
    "\n",
    "DDPG learns two primary networks:\n",
    "\n",
    "1.  **Actor ($\\mu(s; \\theta^\\mu)$):** A policy network that takes a state $s$ and outputs a *specific, deterministic* action $a = \\mu(s)$, rather than a probability distribution over actions. Parameterized by $\\theta^\\mu$.\n",
    "2.  **Critic ($Q(s, a; \\theta^Q)$):** A Q-value network that takes a state $s$ and an action $a$ and outputs the estimated Q-value (expected return) for that state-action pair. Parameterized by $\\theta^Q$.\n",
    "\n",
    "It uses techniques inspired by DQN to stabilize learning:\n",
    "- **Replay Buffer:** Stores experiences $(s_t, a_t, r_t, s_{t+1})$ and samples mini-batches for updates, enabling off-policy learning and breaking data correlations.\n",
    "- **Target Networks:** Maintains separate target networks for both the actor ($\\mu'$) and the critic ($Q'$), which are updated slowly (soft updates) towards the main networks. This provides stable targets for the critic's learning.\n",
    "\n",
    "### Key Ideas: Deterministic Policy & Off-Policy Learning\n",
    "\n",
    "- **Deterministic Policy:** Directly outputting an action simplifies learning in continuous spaces compared to parameterizing a complex continuous probability distribution. However, it necessitates adding explicit exploration noise.\n",
    "- **Off-Policy:** Using a replay buffer allows DDPG to reuse past experiences generated by older policies, making it significantly more sample-efficient than on-policy methods like REINFORCE, A2C, or TRPO/PPO, especially when environment interaction is expensive.\n",
    "\n",
    "## Where and How DDPG is Used\n",
    "\n",
    "DDPG is primarily used for problems with continuous action spaces:\n",
    "\n",
    "1.  **Robotics:** Learning control policies for robotic arms, locomotion, manipulation.\n",
    "2.  **Continuous Control Benchmarks:** Tasks like Pendulum, MountainCarContinuous, MuJoCo environments (Hopper, Walker, etc.).\n",
    "3.  **Autonomous Driving (Simulation):** Controlling steering, acceleration.\n",
    "\n",
    "DDPG is suitable when:\n",
    "- The action space is continuous.\n",
    "- Sample efficiency is important (off-policy learning helps).\n",
    "- A deterministic policy is acceptable or desired.\n",
    "\n",
    "However, DDPG can be sensitive to hyperparameters and sometimes suffers from Q-value overestimation and instability. Extensions like TD3 (Twin Delayed DDPG) were developed to address these issues.\n",
    "\n",
    "## Mathematical Foundation of DDPG\n",
    "\n",
    "### Actor-Critic Framework Recap\n",
    "The core idea remains: the Critic evaluates state-action values, and the Actor updates its policy based on the Critic's evaluation.\n",
    "\n",
    "### Deterministic Policy Gradient Theorem\n",
    "For a deterministic policy $a = \\mu(s; \\theta^\\mu)$, the gradient of the performance objective $J(\\theta^\\mu)$ is given by:\n",
    "$$ \\nabla_{\\theta^\\mu} J(\\theta^\\mu) = \\mathbb{E}_{s \\sim \\rho^beta} [ \\nabla_{\\theta^\\mu} \\mu(s; \\theta^\\mu) \\nabla_a Q(s, a; \\theta^Q)|_{a=\\mu(s; \\theta^\\mu)} ] $$\n",
    "where $\\rho^beta$ is the state distribution under some exploration policy $beta$. Since DDPG is off-policy and uses a replay buffer, the expectation is taken over states sampled from the buffer.\n",
    "Intuitively, the actor's parameters $\\theta^\\mu$ are updated in the direction that increases the Q-value predicted by the critic for the action chosen by the actor.\n",
    "\n",
    "### Critic (Q-Network) Update\n",
    "The critic $Q(s, a; \\theta^Q)$ is updated similarly to DQN, using samples $(s_i, a_i, r_i, s_{i+1})$ from the replay buffer. It minimizes the Mean Squared Bellman Error (MSBE):\n",
    "$$ L(\\theta^Q) = \\mathbb{E}_{(s,a,r,s') \\sim \\mathcal{D}} [ (y - Q(s, a; \\theta^Q))^2 ] $$\n",
    "The target value $y$ is computed using the *target* actor ($\\mu'$) and *target* critic ($Q'$):\n",
    "$$ y = r + \\gamma Q'(s', \\mu'(s'; \\theta^{\\mu'}) ; \\theta^{Q'}) $$\n",
    "Using target networks provides stability by decoupling the target calculation from the parameters being currently updated.\n",
    "\n",
    "### Actor (Policy Network) Update\n",
    "The actor $\\mu(s; \\theta^\\mu)$ is updated by maximizing the expected output of the *main critic* $Q$ with respect to the actor's parameters. This is achieved by gradient ascent on:\n",
    "$$ J(\\theta^\\mu) \\approx \\mathbb{E}_{s \\sim \\mathcal{D}} [ Q(s, \\mu(s; \\theta^\\mu) ; \\theta^Q) ] $$\n",
    "In practice, this means taking the gradient of the critic's output (evaluated with the actor's action) with respect to the actor's parameters. Using PyTorch's autograd, this can be achieved by computing the loss $L(\\theta^\\mu) = -\\frac{1}{N} \\sum_i Q(s_i, \\mu(s_i; \\theta^\\mu) ; \\theta^Q)$ and performing gradient descent.\n",
    "\n",
    "### Target Networks and Soft Updates\n",
    "To stabilize learning, DDPG uses target networks $Q'(s, a; \\theta^{Q'})$ and $\\mu'(s; \\theta^{\\mu'})$ with parameters $\\theta^{Q'}$ and $\\theta^{\\mu'}$. These are not trained directly but are updated slowly towards the main network parameters ($\theta^Q, \\theta^\\mu$) after each update step using \"soft\" updates:\n",
    "$$ \\theta' \\leftarrow \\tau \\theta + (1 - \\tau) \\theta' $$\n",
    "where $\\tau \\ll 1$ (e.g., 0.001, 0.005) is the soft update rate. This makes the target values $y$ change slowly, improving stability.\n",
    "\n",
    "### Exploration Noise\n",
    "Since the actor policy is deterministic, exploration must be added externally during training rollouts. A common approach is to add noise to the actor's output action before executing it in the environment:\n",
    "$$ a_t = \\mu(s_t; \\theta^\\mu) + \\mathcal{N}_t $$\n",
    "where $\\mathcal{N}_t$ is a noise process (e.g., Ornstein-Uhlenbeck process for temporally correlated noise, or simpler Gaussian noise). The noise level is often annealed over time.\n",
    "\n",
    "## Step-by-Step Explanation of DDPG\n",
    "\n",
    "1.  **Initialize**: Actor network $\\mu(s; \\theta^\\mu)$, Critic network $Q(s, a; \\theta^Q)$.\n",
    "2.  **Initialize**: Target networks $\\mu'(s; \\theta^{\\mu'})$ and $Q'(s, a; \\theta^{Q'})$ with $\\theta^{\\mu'} \\leftarrow \\theta^\\mu$, $\\theta^{Q'} \\leftarrow \\theta^Q$.\n",
    "3.  **Initialize**: Replay buffer $\\mathcal{D}$, noise process $\\mathcal{N}$.\n",
    "4.  **For each episode**:\n",
    "    a.  Reset environment, get initial state $s_0$. Reset noise process.\n",
    "    b.  **For each step $t$**:\n",
    "        i.   Select action $a_t = \\mu(s_t; \\theta^\\mu) + \\mathcal{N}_t$. Clip action if necessary to fit environment bounds.\n",
    "        ii.  Execute $a_t$, observe reward $r_t$, next state $s_{t+1}$, done flag $d_t$.\n",
    "        iii. Store transition $(s_t, a_t, r_t, s_{t+1}, d_t)$ in $\\mathcal{D}$.\n",
    "        iv.  **Sample mini-batch**: Get random batch of $N$ transitions from $\\mathcal{D}$.\n",
    "        v.   **Calculate Critic Target**: For each sample $j$ in batch:\n",
    "             $a'_{j+1} = \\mu'(s_{j+1}; \\theta^{\\mu'})$\n",
    "             $y_j = r_j + \\gamma (1-d_j) Q'(s_{j+1}, a'_{j+1} ; \\theta^{Q'})$\n",
    "        vi.  **Update Critic**: Minimize loss $L = \\frac{1}{N} \\sum_j (y_j - Q(s_j, a_j; \\theta^Q))^2$ via gradient descent.\n",
    "        vii. **Update Actor**: Maximize objective (or minimize negative objective) $J = \\frac{1}{N} \\sum_j Q(s_j, \\mu(s_j; \\theta^\\mu); \\theta^Q)$ using gradient ascent (or descent on $-J$). Note: Gradients flow from critic output back through the actor.\n",
    "        viii.**Update Target Networks**: Perform soft updates:\n",
    "             $\\theta^{Q'} \\leftarrow \\tau \\theta^Q + (1 - \\tau) \\theta^{Q'}$\n",
    "             $\\theta^{\\mu'} \\leftarrow \\tau \\theta^\\mu + (1 - \\tau) \\theta^{\\mu'}$\n",
    "        ix.  $s_t \\leftarrow s_{t+1}$.\n",
    "        x.   If $d_t$, break episode.\n",
    "5.  **Repeat**: Until convergence or max episodes.\n",
    "\n",
    "## Key Components of DDPG\n",
    "\n",
    "### Actor Network (Deterministic Policy)\n",
    "- Maps state $s$ to a specific continuous action $a = \\mu(s)$.\n",
    "- Trained to output actions that maximize the Q-value estimated by the critic.\n",
    "- Often uses `tanh` activation on the output layer, scaled to match action bounds.\n",
    "\n",
    "### Critic Network (Q-Value Function)\n",
    "- Estimates the value $Q(s, a)$ of taking action $a$ in state $s$.\n",
    "- Takes both state and action as input.\n",
    "- Trained using Bellman equation targets derived from target networks.\n",
    "\n",
    "### Target Actor & Target Critic Networks\n",
    "- Separate copies of the actor and critic networks used for calculating stable target values ($y$) for the critic update.\n",
    "- Updated slowly via soft updates.\n",
    "\n",
    "### Replay Buffer\n",
    "- Stores $(s, a, r, s', done)$ transitions.\n",
    "- Allows off-policy learning and breaks data correlations by sampling random mini-batches.\n",
    "\n",
    "### Exploration Noise Process\n",
    "- Added to the deterministic actor's output during training rollouts to encourage exploration.\n",
    "- Examples: Ornstein-Uhlenbeck (correlated noise), Gaussian noise. Often annealed over time.\n",
    "\n",
    "### Soft Target Updates\n",
    "- Slowly blends the main network parameters into the target network parameters using rate $\\tau$.\n",
    "- Key for stability compared to infrequent hard updates.\n",
    "\n",
    "### Hyperparameters\n",
    "- Replay buffer size, batch size.\n",
    "- Learning rates for actor ($\\alpha_\\mu$) and critic ($\\alpha_Q$).\n",
    "- Target network soft update rate ($\tau$).\n",
    "- Discount factor ($\\gamma$).\n",
    "- Exploration noise parameters (type, scale, annealing).\n",
    "- Network architectures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Practical Example: Pendulum Environment\n",
    "\n",
    "![Pendulum]()\n",
    "\n",
    "### Why Pendulum? (Continuous Actions)\n",
    "DDPG is designed for environments where the agent must output continuous values (like applying a specific torque, setting a velocity, or positioning a robotic arm joint). The Grid World has discrete actions (Up, Down, Left, Right). The `Pendulum-v1` environment is a standard benchmark with:\n",
    "- **Continuous State:** `[cos(theta), sin(theta), theta_dot]`\n",
    "- **Continuous Action:** Torque applied to the joint, a single value usually between [-2.0, 2.0].\n",
    "\n",
    "Using this environment allows us to correctly demonstrate DDPG's handling of continuous actions. **This requires the `gymnasium` library, deviating slightly from the 'basic libraries only' constraint of the reference DQN notebook, as DDPG is fundamentally suited for such environments.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setting up the Environment\n",
    "\n",
    "Import libraries, including `gymnasium`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cpu\n"
     ]
    }
   ],
   "source": [
    "# Import necessary libraries\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "import math\n",
    "from collections import namedtuple, deque\n",
    "from itertools import count\n",
    "from typing import List, Tuple, Dict, Optional, Callable, Any, Union\n",
    "import copy\n",
    "import os\n",
    "import time\n",
    "\n",
    "# Import PyTorch\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "\n",
    "# Import Gymnasium for the continuous environment\n",
    "try:\n",
    "    import gymnasium as gym\n",
    "except ImportError:\n",
    "    print(\"Gymnasium not found. Please install using 'pip install gymnasium' or 'pip install gym[classic_control]'\" )\n",
    "    # You might want to exit or raise an error here if gym is essential\n",
    "    gym = None # Set gym to None if import fails\n",
    "\n",
    "# Set up device\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"Using device: {device}\")\n",
    "\n",
    "# Set random seeds for reproducibility\n",
    "seed = 42\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed)\n",
    "if torch.cuda.is_available():\n",
    "    torch.cuda.manual_seed_all(seed)\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating the Continuous Environment (Gymnasium)\n",
    "\n",
    "Instantiate the Pendulum environment using Gymnasium."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pendulum Environment:\n",
      "State Dim: 3\n",
      "Action Dim: 1\n",
      "Action Low: -2.0\n",
      "Action High: 2.0\n",
      "Initial observation: [-0.6306115   0.77609867  0.39473605]\n"
     ]
    }
   ],
   "source": [
    "# Instantiate the Pendulum environment\n",
    "if gym is not None:\n",
    "    try:\n",
    "        # Create the environment\n",
    "        env = gym.make('Pendulum-v1')\n",
    "        \n",
    "        # Set seeds for environment reproducibility\n",
    "        env.reset(seed=seed)\n",
    "        env.action_space.seed(seed)\n",
    "\n",
    "        # Get state and action space dimensions\n",
    "        n_observations_ddpg = env.observation_space.shape[0]\n",
    "        n_actions_ddpg = env.action_space.shape[0] # DDPG handles continuous actions\n",
    "        action_low = env.action_space.low[0]\n",
    "        action_high = env.action_space.high[0]\n",
    "\n",
    "        print(f\"Pendulum Environment:\")\n",
    "        print(f\"State Dim: {n_observations_ddpg}\")\n",
    "        print(f\"Action Dim: {n_actions_ddpg}\")\n",
    "        print(f\"Action Low: {action_low}\")\n",
    "        print(f\"Action High: {action_high}\")\n",
    "        \n",
    "        # Test reset\n",
    "        obs, info = env.reset()\n",
    "        print(f\"Initial observation: {obs}\")\n",
    "        \n",
    "    except Exception as e:\n",
    "        print(f\"Error creating Gymnasium environment: {e}\")\n",
    "        # Set dummy values if env creation fails\n",
    "        n_observations_ddpg = 3\n",
    "        n_actions_ddpg = 1\n",
    "        action_low = -2.0\n",
    "        action_high = 2.0\n",
    "        env = None # Mark env as unusable\n",
    "else:\n",
    "    print(\"Gymnasium not available. Cannot create Pendulum environment.\")\n",
    "    # Set dummy values\n",
    "    n_observations_ddpg = 3\n",
    "    n_actions_ddpg = 1\n",
    "    action_low = -2.0\n",
    "    action_high = 2.0\n",
    "    env = None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implementing the DDPG Algorithm\n",
    "\n",
    "Define the Actor, Critic, Replay Buffer, Noise, and update logic.\n",
    "\n",
    "### Defining the Actor Network\n",
    "\n",
    "Outputs a deterministic continuous action, scaled by `tanh` and the environment's action bounds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ActorNetwork(nn.Module):\n",
    "    \"\"\" Deterministic Actor Network for DDPG \"\"\"\n",
    "    def __init__(self, n_observations: int, n_actions: int, action_high_bound: float):\n",
    "        super(ActorNetwork, self).__init__()\n",
    "        self.action_high_bound = action_high_bound\n",
    "        # Simple MLP architecture\n",
    "        self.layer1 = nn.Linear(n_observations, 256)\n",
    "        self.layer2 = nn.Linear(256, 256)\n",
    "        self.layer3 = nn.Linear(256, n_actions)\n",
    "        \n",
    "        # Initialize final layer weights for smaller initial outputs\n",
    "        # Often helps in DDPG\n",
    "        nn.init.uniform_(self.layer3.weight, -3e-3, 3e-3)\n",
    "        nn.init.uniform_(self.layer3.bias, -3e-3, 3e-3)\n",
    "\n",
    "    def forward(self, state: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"\n",
    "        Maps state to a deterministic action.\n",
    "        Parameters:\n",
    "        - state (torch.Tensor): Input state tensor.\n",
    "        Returns:\n",
    "        - torch.Tensor: The deterministic action, scaled to environment bounds.\n",
    "        \"\"\"\n",
    "        x = F.relu(self.layer1(state))\n",
    "        x = F.relu(self.layer2(x))\n",
    "        # Use tanh to bound output between -1 and 1\n",
    "        action_tanh = torch.tanh(self.layer3(x))\n",
    "        # Scale to the environment's action bounds\n",
    "        scaled_action = action_tanh * self.action_high_bound\n",
    "        return scaled_action"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining the Critic Network\n",
    "\n",
    "Outputs a Q-value given state and action. Action is typically concatenated after initial state processing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CriticNetwork(nn.Module):\n",
    "    \"\"\" Q-Value Critic Network for DDPG \"\"\"\n",
    "    def __init__(self, n_observations: int, n_actions: int):\n",
    "        super(CriticNetwork, self).__init__()\n",
    "        # Process state separately first\n",
    "        self.state_layer1 = nn.Linear(n_observations, 256)\n",
    "        # Combine state features and action in the second layer\n",
    "        self.combined_layer2 = nn.Linear(256 + n_actions, 256)\n",
    "        self.output_layer3 = nn.Linear(256, 1)\n",
    "\n",
    "    def forward(self, state: torch.Tensor, action: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"\n",
    "        Maps state and action to a Q-value.\n",
    "        Parameters:\n",
    "        - state (torch.Tensor): Input state tensor.\n",
    "        - action (torch.Tensor): Input action tensor.\n",
    "        Returns:\n",
    "        - torch.Tensor: The estimated Q(s, a) value.\n",
    "        \"\"\"\n",
    "        state_features = F.relu(self.state_layer1(state))\n",
    "        # Concatenate state features and action\n",
    "        combined = torch.cat([state_features, action], dim=1)\n",
    "        x = F.relu(self.combined_layer2(combined))\n",
    "        q_value = self.output_layer3(x)\n",
    "        return q_value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining the Replay Memory\n",
    "\n",
    "Standard replay buffer implementation, similar to DQN."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the structure for storing transitions\n",
    "Transition = namedtuple('Transition',\n",
    "                        ('state', 'action', 'reward', 'next_state', 'done'))\n",
    "\n",
    "# Define the Replay Memory class\n",
    "class ReplayMemory(object):\n",
    "    \"\"\" Stores transitions and allows sampling batches. \"\"\"\n",
    "    def __init__(self, capacity: int):\n",
    "        \"\"\"\n",
    "        Initialize the Replay Memory.\n",
    "        Parameters:\n",
    "        - capacity (int): Maximum number of transitions to store.\n",
    "        \"\"\"\n",
    "        # Use deque for efficient FIFO buffer\n",
    "        self.memory = deque([], maxlen=capacity)\n",
    "\n",
    "    def push(self, *args: Any) -> None:\n",
    "        \"\"\"\n",
    "        Save a transition.\n",
    "        Parameters:\n",
    "        - *args: The transition elements (state, action, reward, next_state, done).\n",
    "                 State/action/reward/next_state should be tensors or easily convertible.\n",
    "        \"\"\"\n",
    "        # Ensure data is stored appropriately (e.g., tensors on CPU)\n",
    "        processed_args = []\n",
    "        for arg in args:\n",
    "            if isinstance(arg, torch.Tensor):\n",
    "                processed_args.append(arg.cpu()) # Store tensors on CPU\n",
    "            elif isinstance(arg, (bool, float, int)):\n",
    "                 # Convert bool/float/int to tensors for consistency if needed later,\n",
    "                 # but storing primitives is fine too.\n",
    "                 # Let's store primitives for done/reward, tensors for states/actions.\n",
    "                 processed_args.append(arg) \n",
    "            elif isinstance(arg, np.ndarray):\n",
    "                 processed_args.append(torch.from_numpy(arg).float().cpu()) # Convert numpy arrays\n",
    "            else:\n",
    "                 processed_args.append(arg) # Keep others as is\n",
    "                 \n",
    "        self.memory.append(Transition(*processed_args))\n",
    "\n",
    "    def sample(self, batch_size: int) -> List[Transition]:\n",
    "        \"\"\"\n",
    "        Sample a random batch of transitions from memory.\n",
    "        Parameters:\n",
    "        - batch_size (int): The number of transitions to sample.\n",
    "        Returns:\n",
    "        - List[Transition]: A list containing the sampled transitions.\n",
    "        \"\"\"\n",
    "        return random.sample(self.memory, batch_size)\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        \"\"\" Return the current size of the memory. \"\"\"\n",
    "        return len(self.memory)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining the Exploration Noise\n",
    "\n",
    "A simple Gaussian noise implementation. OU noise is another common choice but slightly more complex."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GaussianNoise:\n",
    "    \"\"\" Simple Gaussian Noise process for exploration. \"\"\"\n",
    "    def __init__(self, action_dimension: int, mean: float = 0.0, std_dev: float = 0.1):\n",
    "        \"\"\"\n",
    "        Initialize Gaussian noise.\n",
    "        Parameters:\n",
    "        - action_dimension (int): Dimension of the action space.\n",
    "        - mean (float): Mean of the Gaussian distribution.\n",
    "        - std_dev (float): Standard deviation of the Gaussian distribution.\n",
    "        \"\"\"\n",
    "        self.action_dim = action_dimension\n",
    "        self.mean = mean\n",
    "        self.std_dev = std_dev\n",
    "\n",
    "    def get_noise(self) -> np.ndarray:\n",
    "        \"\"\" Generate noise. \"\"\"\n",
    "        # Generate noise using numpy\n",
    "        noise = np.random.normal(self.mean, self.std_dev, self.action_dim)\n",
    "        return noise\n",
    "\n",
    "    def reset(self) -> None:\n",
    "        \"\"\" Reset noise state (no state for Gaussian noise). \"\"\"\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Soft Update Function\n",
    "\n",
    "Helper function to perform the soft update of target network parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def soft_update(target_net: nn.Module, main_net: nn.Module, tau: float) -> None:\n",
    "    \"\"\"\n",
    "    Performs a soft update of the target network parameters.\n",
    "    θ_target = τ*θ_local + (1 - τ)*θ_target\n",
    "\n",
    "    Parameters:\n",
    "    - target_net (nn.Module): The target network to be updated.\n",
    "    - main_net (nn.Module): The main network providing the parameters.\n",
    "    - tau (float): The soft update factor (τ).\n",
    "    \"\"\"\n",
    "    for target_param, main_param in zip(target_net.parameters(), main_net.parameters()):\n",
    "        target_param.data.copy_(tau * main_param.data + (1.0 - tau) * target_param.data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The DDPG Update Step\n",
    "\n",
    "Function to perform one DDPG update using a batch sampled from the replay buffer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_ddpg(memory: ReplayMemory,\n",
    "                  batch_size: int,\n",
    "                  actor: ActorNetwork,\n",
    "                  critic: CriticNetwork,\n",
    "                  target_actor: ActorNetwork,\n",
    "                  target_critic: CriticNetwork,\n",
    "                  actor_optimizer: optim.Optimizer,\n",
    "                  critic_optimizer: optim.Optimizer,\n",
    "                  gamma: float,\n",
    "                  tau: float) -> Tuple[float, float]:\n",
    "    \"\"\"\n",
    "    Performs one DDPG update step (actor and critic).\n",
    "\n",
    "    Parameters:\n",
    "    - memory: The ReplayMemory object.\n",
    "    - batch_size: The size of the mini-batch to sample.\n",
    "    - actor, critic: Main networks.\n",
    "    - target_actor, target_critic: Target networks.\n",
    "    - actor_optimizer, critic_optimizer: Optimizers.\n",
    "    - gamma: Discount factor.\n",
    "    - tau: Soft update factor.\n",
    "\n",
    "    Returns:\n",
    "    - Tuple[float, float]: Critic loss and Actor loss for logging.\n",
    "    \"\"\"\n",
    "    # Don't update if buffer doesn't have enough samples\n",
    "    if len(memory) < batch_size:\n",
    "        return 0.0, 0.0\n",
    "\n",
    "    # Sample a batch\n",
    "    transitions = memory.sample(batch_size)\n",
    "    batch = Transition(*zip(*transitions))\n",
    "\n",
    "    # Unpack batch data and move to device\n",
    "    # Ensure states/next_states are FloatTensors, actions are FloatTensors, rewards/dones are FloatTensors\n",
    "    state_batch = torch.stack([s for s in batch.state if s is not None]).float().to(device)\n",
    "    action_batch = torch.stack([a for a in batch.action if a is not None]).float().to(device)\n",
    "    reward_batch = torch.tensor(batch.reward, dtype=torch.float32, device=device).unsqueeze(1)\n",
    "    next_state_batch = torch.stack([s for s in batch.next_state if s is not None]).float().to(device)\n",
    "    # Convert boolean 'done' flags to float tensor (1.0 for done, 0.0 for not done)\n",
    "    done_batch = torch.tensor(batch.done, dtype=torch.float32, device=device).unsqueeze(1)\n",
    "\n",
    "    # --- Critic Update --- \n",
    "    \n",
    "    # 1. Calculate target Q-values (y)\n",
    "    with torch.no_grad(): # Target calculations don't need gradient tracking\n",
    "        # Get next actions from target actor\n",
    "        next_actions = target_actor(next_state_batch)\n",
    "        # Get Q-values for next states/actions from target critic\n",
    "        target_q_values = target_critic(next_state_batch, next_actions)\n",
    "        # Compute the target y = r + gamma * Q'_target * (1 - done)\n",
    "        y = reward_batch + gamma * (1.0 - done_batch) * target_q_values\n",
    "\n",
    "    # 2. Get current Q-values from main critic\n",
    "    current_q_values = critic(state_batch, action_batch)\n",
    "\n",
    "    # 3. Compute Critic loss (MSE)\n",
    "    critic_loss = F.mse_loss(current_q_values, y)\n",
    "\n",
    "    # 4. Optimize the Critic\n",
    "    critic_optimizer.zero_grad()\n",
    "    critic_loss.backward()\n",
    "    # Optional: Gradient clipping for critic\n",
    "    # torch.nn.utils.clip_grad_norm_(critic.parameters(), 1.0)\n",
    "    critic_optimizer.step()\n",
    "\n",
    "    # --- Actor Update --- \n",
    "\n",
    "    # 1. Calculate Actor loss (negative mean Q-value for actor's actions)\n",
    "    # We want to maximize Q(s, mu(s)), so minimize -Q(s, mu(s))\n",
    "    actor_actions = actor(state_batch)\n",
    "    q_values_for_actor = critic(state_batch, actor_actions) # Use main critic\n",
    "    actor_loss = -q_values_for_actor.mean()\n",
    "\n",
    "    # 2. Optimize the Actor\n",
    "    actor_optimizer.zero_grad()\n",
    "    actor_loss.backward()\n",
    "    # Optional: Gradient clipping for actor\n",
    "    # torch.nn.utils.clip_grad_norm_(actor.parameters(), 1.0)\n",
    "    actor_optimizer.step()\n",
    "\n",
    "    # --- Update Target Networks --- \n",
    "    soft_update(target_critic, critic, tau)\n",
    "    soft_update(target_actor, actor, tau)\n",
    "\n",
    "    return critic_loss.item(), actor_loss.item()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Running the DDPG Algorithm\n",
    "\n",
    "Set up hyperparameters, initialize networks, optimizers, buffer, and noise, then run the DDPG training loop.\n",
    "\n",
    "### Hyperparameter Setup\n",
    "\n",
    "Define DDPG hyperparameters, considering the Pendulum environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hyperparameters for DDPG on Pendulum-v1\n",
    "BUFFER_SIZE = int(1e6)     # Replay buffer capacity\n",
    "BATCH_SIZE = 128           # Mini-batch size for updates\n",
    "GAMMA_DDPG = 0.99          # Discount factor\n",
    "TAU = 1e-3                 # Soft update factor for target networks\n",
    "ACTOR_LR_DDPG = 1e-4       # Learning rate for the actor\n",
    "CRITIC_LR_DDPG = 1e-3      # Learning rate for the critic (often higher than actor)\n",
    "WEIGHT_DECAY = 0           # L2 weight decay for critic optimizer (optional)\n",
    "\n",
    "NOISE_STD_DEV = 0.2        # Standard deviation for Gaussian exploration noise\n",
    "NOISE_DECAY = 0.999        # Decay factor for noise std dev (optional annealing)\n",
    "MIN_NOISE_STD_DEV = 0.01   # Minimum noise standard deviation\n",
    "\n",
    "NUM_EPISODES_DDPG = 100    # Number of training episodes\n",
    "MAX_STEPS_PER_EPISODE_DDPG = 500 # Max steps per episode in Pendulum\n",
    "UPDATE_EVERY = 1           # How often to perform update steps (e.g., every step)\n",
    "NUM_UPDATES = 1            # Number of update steps per UPDATE_EVERY interval"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialization\n",
    "\n",
    "Initialize actor, critic, target networks, optimizers, replay buffer, and noise process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ensure environment was created successfully\n",
    "if env is None:\n",
    "    raise RuntimeError(\"Gymnasium environment 'Pendulum-v1' could not be created. Ensure gymnasium is installed.\")\n",
    "\n",
    "# Initialize Networks\n",
    "actor_ddpg = ActorNetwork(n_observations_ddpg, n_actions_ddpg, action_high).to(device)\n",
    "critic_ddpg = CriticNetwork(n_observations_ddpg, n_actions_ddpg).to(device)\n",
    "\n",
    "# Initialize Target Networks (hard copy initially)\n",
    "target_actor_ddpg = ActorNetwork(n_observations_ddpg, n_actions_ddpg, action_high).to(device)\n",
    "target_critic_ddpg = CriticNetwork(n_observations_ddpg, n_actions_ddpg).to(device)\n",
    "target_actor_ddpg.load_state_dict(actor_ddpg.state_dict())\n",
    "target_critic_ddpg.load_state_dict(critic_ddpg.state_dict())\n",
    "\n",
    "# Initialize Optimizers\n",
    "actor_optimizer_ddpg = optim.Adam(actor_ddpg.parameters(), lr=ACTOR_LR_DDPG)\n",
    "critic_optimizer_ddpg = optim.Adam(critic_ddpg.parameters(), lr=CRITIC_LR_DDPG, weight_decay=WEIGHT_DECAY)\n",
    "\n",
    "# Initialize Replay Memory\n",
    "memory_ddpg = ReplayMemory(BUFFER_SIZE)\n",
    "\n",
    "# Initialize Noise Process\n",
    "noise = GaussianNoise(n_actions_ddpg, std_dev=NOISE_STD_DEV)\n",
    "current_noise_std_dev = NOISE_STD_DEV\n",
    "\n",
    "# Lists for plotting\n",
    "ddpg_episode_rewards = []\n",
    "ddpg_episode_actor_losses = []\n",
    "ddpg_episode_critic_losses = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training Loop\n",
    "\n",
    "The DDPG training loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting DDPG Training on Pendulum-v1...\n",
      "Episode 10/100 | Avg Reward: -1490.10 | Actor Loss: 13.9089 | Critic Loss: 1.2726 | Noise Std: 0.198\n",
      "Episode 20/100 | Avg Reward: -1443.33 | Actor Loss: 26.3751 | Critic Loss: 3.1495 | Noise Std: 0.196\n",
      "Episode 30/100 | Avg Reward: -1376.16 | Actor Loss: 38.1891 | Critic Loss: 7.6305 | Noise Std: 0.194\n",
      "Episode 40/100 | Avg Reward: -951.15 | Actor Loss: 46.8234 | Critic Loss: 11.8599 | Noise Std: 0.192\n",
      "Episode 50/100 | Avg Reward: -870.70 | Actor Loss: 53.7064 | Critic Loss: 12.6563 | Noise Std: 0.190\n",
      "Episode 60/100 | Avg Reward: -359.14 | Actor Loss: 56.8262 | Critic Loss: 15.7296 | Noise Std: 0.188\n",
      "Episode 70/100 | Avg Reward: -435.37 | Actor Loss: 57.6520 | Critic Loss: 17.4160 | Noise Std: 0.186\n",
      "Episode 80/100 | Avg Reward: -381.79 | Actor Loss: 58.4119 | Critic Loss: 19.1516 | Noise Std: 0.185\n",
      "Episode 90/100 | Avg Reward: -115.01 | Actor Loss: 58.0655 | Critic Loss: 20.3253 | Noise Std: 0.183\n",
      "Episode 100/100 | Avg Reward: -240.34 | Actor Loss: 56.7522 | Critic Loss: 22.7741 | Noise Std: 0.181\n",
      "Pendulum-v1 Training Finished (DDPG).\n"
     ]
    }
   ],
   "source": [
    "print(\"Starting DDPG Training on Pendulum-v1...\")\n",
    "\n",
    "# --- DDPG Training Loop ---\n",
    "total_steps = 0\n",
    "for i_episode in range(1, NUM_EPISODES_DDPG + 1):\n",
    "    # Reset environment and noise\n",
    "    state_np, info = env.reset()\n",
    "    state = torch.from_numpy(state_np).float().to(device)\n",
    "    noise.reset()\n",
    "    noise.std_dev = current_noise_std_dev # Set current noise level\n",
    "    \n",
    "    episode_reward = 0\n",
    "    actor_losses = []\n",
    "    critic_losses = []\n",
    "\n",
    "    for t in range(MAX_STEPS_PER_EPISODE_DDPG):\n",
    "        # --- Action Selection --- \n",
    "        actor_ddpg.eval() # Set actor to evaluation mode for action selection\n",
    "        with torch.no_grad():\n",
    "            action_deterministic = actor_ddpg(state)\n",
    "        actor_ddpg.train() # Set back to training mode\n",
    "        \n",
    "        # Add exploration noise\n",
    "        action_noise = noise.get_noise()\n",
    "        action_noisy = action_deterministic.cpu().numpy() + action_noise # Add noise on CPU\n",
    "        \n",
    "        # Clip action to environment bounds\n",
    "        action_clipped = np.clip(action_noisy, action_low, action_high)\n",
    "\n",
    "        # --- Environment Interaction --- \n",
    "        next_state_np, reward, terminated, truncated, _ = env.step(action_clipped)\n",
    "        done = terminated or truncated\n",
    "        \n",
    "        # --- Store Experience --- \n",
    "        # Convert to tensors for storage (store action *before* clipping for critic? No, store clipped action)\n",
    "        action_tensor = torch.from_numpy(action_clipped).float() # Store the executed action\n",
    "        next_state_tensor = torch.from_numpy(next_state_np).float()\n",
    "        # Note: state was already a tensor\n",
    "        memory_ddpg.push(state, action_tensor, reward, next_state_tensor, done)\n",
    "\n",
    "        state = next_state_tensor.to(device) # Update state for next loop\n",
    "        episode_reward += reward\n",
    "        total_steps += 1\n",
    "\n",
    "        # --- Update Networks --- \n",
    "        if len(memory_ddpg) > BATCH_SIZE and total_steps % UPDATE_EVERY == 0:\n",
    "            for _ in range(NUM_UPDATES):\n",
    "                c_loss, a_loss = update_ddpg(\n",
    "                    memory_ddpg, BATCH_SIZE, \n",
    "                    actor_ddpg, critic_ddpg,\n",
    "                    target_actor_ddpg, target_critic_ddpg,\n",
    "                    actor_optimizer_ddpg, critic_optimizer_ddpg,\n",
    "                    GAMMA_DDPG, TAU\n",
    "                )\n",
    "                critic_losses.append(c_loss)\n",
    "                actor_losses.append(a_loss)\n",
    "\n",
    "        if done:\n",
    "            break\n",
    "            \n",
    "    # --- End of Episode --- \n",
    "    ddpg_episode_rewards.append(episode_reward)\n",
    "    ddpg_episode_actor_losses.append(np.mean(actor_losses) if actor_losses else 0)\n",
    "    ddpg_episode_critic_losses.append(np.mean(critic_losses) if critic_losses else 0)\n",
    "    \n",
    "    # Anneal noise\n",
    "    current_noise_std_dev = max(MIN_NOISE_STD_DEV, current_noise_std_dev * NOISE_DECAY)\n",
    "    \n",
    "    # Print progress\n",
    "    if i_episode % 10 == 0:\n",
    "        avg_reward = np.mean(ddpg_episode_rewards[-10:])\n",
    "        avg_actor_loss = np.mean(ddpg_episode_actor_losses[-10:])\n",
    "        avg_critic_loss = np.mean(ddpg_episode_critic_losses[-10:])\n",
    "        print(f\"Episode {i_episode}/{NUM_EPISODES_DDPG} | Avg Reward: {avg_reward:.2f} | Actor Loss: {avg_actor_loss:.4f} | Critic Loss: {avg_critic_loss:.4f} | Noise Std: {current_noise_std_dev:.3f}\")\n",
    "\n",
    "print(\"Pendulum-v1 Training Finished (DDPG).\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualizing the Learning Process\n",
    "\n",
    "Plot episode rewards and average losses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1800x400 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting results for DDPG on Pendulum-v1\n",
    "plt.figure(figsize=(18, 4))\n",
    "\n",
    "# Episode Rewards\n",
    "plt.subplot(1, 3, 1)\n",
    "plt.plot(ddpg_episode_rewards)\n",
    "plt.title('DDPG Pendulum: Episode Rewards')\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Total Reward')\n",
    "plt.grid(True)\n",
    "# Add moving average\n",
    "if len(ddpg_episode_rewards) >= 10:\n",
    "    rewards_ma_ddpg = np.convolve(ddpg_episode_rewards, np.ones(10)/10, mode='valid')\n",
    "    plt.plot(np.arange(len(rewards_ma_ddpg)) + 9, rewards_ma_ddpg, label='10-episode MA', color='orange')\n",
    "    plt.legend()\n",
    "\n",
    "# Critic Loss\n",
    "plt.subplot(1, 3, 2)\n",
    "plt.plot(ddpg_episode_critic_losses)\n",
    "plt.title('DDPG Pendulum: Avg Critic Loss per Episode')\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('MSE Loss')\n",
    "plt.grid(True)\n",
    "if len(ddpg_episode_critic_losses) >= 10:\n",
    "    closs_ma_ddpg = np.convolve(ddpg_episode_critic_losses, np.ones(10)/10, mode='valid')\n",
    "    plt.plot(np.arange(len(closs_ma_ddpg)) + 9, closs_ma_ddpg, label='10-episode MA', color='orange')\n",
    "    plt.legend()\n",
    "\n",
    "# Actor Loss\n",
    "plt.subplot(1, 3, 3)\n",
    "plt.plot(ddpg_episode_actor_losses)\n",
    "plt.title('DDPG Pendulum: Avg Actor Loss per Episode')\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Avg -Q Value')\n",
    "plt.grid(True)\n",
    "if len(ddpg_episode_actor_losses) >= 10:\n",
    "    aloss_ma_ddpg = np.convolve(ddpg_episode_actor_losses, np.ones(10)/10, mode='valid')\n",
    "    plt.plot(np.arange(len(aloss_ma_ddpg)) + 9, aloss_ma_ddpg, label='10-episode MA', color='orange')\n",
    "    plt.legend()\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Analysis of DDPG Learning Curves (Pendulum):**\n",
    "\n",
    "1.  **Episode Rewards (Left Plot):**\n",
    "    The agent shows clear learning, with total rewards trending significantly upwards (becoming less negative) from around -1500 towards -200. This indicates substantial improvement in solving the pendulum swing-up task. High volatility in raw rewards is typical for DDPG on sensitive tasks like Pendulum, but the moving average confirms the positive learning trend.\n",
    "\n",
    "2.  **Avg Critic Loss per Episode (Middle Plot):**\n",
    "    The Critic's MSE loss surprisingly *increases* throughout training. While counter-intuitive, this often happens in DDPG as the policy improves and explores higher-value (less negative) state-action pairs. The critic constantly adapts to predict these increasing target Q-values, leading to a rising loss rather than convergence to zero, though it might also hint at some learning instability.\n",
    "\n",
    "3.  **Avg Actor Loss per Episode (Right Plot):**\n",
    "    This plot (representing the average Q-value predicted for the actor's actions) shows a strong, smooth upward trend, correlating well with the reward improvement. It signifies the actor is successfully learning actions that the critic evaluates as increasingly better (leading to higher Q-values). The plateau towards the end suggests convergence towards an effective policy.\n",
    "\n",
    "**Overall Conclusion:**\n",
    "DDPG successfully learned to improve its performance significantly on the continuous control Pendulum task, pushing rewards towards better values. The actor effectively optimized its policy based on the critic's evaluations. While the increasing critic loss warrants attention (potentially indicating the critic struggles to keep up with the actor or changing value scales), the overall reward trend confirms successful learning, albeit with the volatility often associated with DDPG."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analyzing the Learned Policy (Testing)\n",
    "\n",
    "Visualize the performance of the trained DDPG agent by running it deterministically (no noise) in the environment for a few episodes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--- Testing DDPG Agent (3 episodes) ---\n",
      "Test Episode 1: Reward = -130.24, Length = 200\n",
      "Test Episode 2: Reward = -118.55, Length = 200\n",
      "Test Episode 3: Reward = -369.77, Length = 200\n",
      "--- Testing Complete. Average Reward: -206.19 ---\n"
     ]
    }
   ],
   "source": [
    "def test_ddpg_agent(actor_net: ActorNetwork, \n",
    "                    env_instance: gym.Env, \n",
    "                    num_episodes: int = 5, \n",
    "                    render: bool = False, # Set to True to visualize\n",
    "                    seed_offset: int = 1000) -> None:\n",
    "    \"\"\"\n",
    "    Tests the trained DDPG agent deterministically.\n",
    "    \n",
    "    Parameters:\n",
    "    - actor_net: The trained actor network.\n",
    "    - env_instance: An instance of the environment.\n",
    "    - num_episodes: Number of test episodes to run.\n",
    "    - render: If True, attempts to render the environment.\n",
    "    - seed_offset: Offset for seeding test episodes differently from training.\n",
    "    \"\"\"\n",
    "    if env_instance is None:\n",
    "        print(\"Environment not available for testing.\")\n",
    "        return\n",
    "        \n",
    "    actor_net.eval() # Set actor to evaluation mode (important!)\n",
    "    \n",
    "    print(f\"\\n--- Testing DDPG Agent ({num_episodes} episodes) ---\")\n",
    "    all_rewards = []\n",
    "    for i in range(num_episodes):\n",
    "        state_np, info = env_instance.reset(seed=seed + seed_offset + i) # Different seed for testing\n",
    "        state = torch.from_numpy(state_np).float().to(device)\n",
    "        episode_reward = 0\n",
    "        done = False\n",
    "        t = 0\n",
    "        while not done:\n",
    "            if render:\n",
    "                try:\n",
    "                    # Try rendering (might require extra setup depending on environment/system)\n",
    "                    env_instance.render()\n",
    "                    time.sleep(0.01) # Slow down rendering slightly\n",
    "                except Exception as e:\n",
    "                    print(f\"Rendering failed: {e}. Disabling render.\")\n",
    "                    render = False # Disable rendering if it fails\n",
    "            \n",
    "            with torch.no_grad():\n",
    "                # Select action deterministically (no noise)\n",
    "                action = actor_net(state).cpu().numpy()\n",
    "            \n",
    "            # Clipping is still important even in testing\n",
    "            action_clipped = np.clip(action, env_instance.action_space.low, env_instance.action_space.high)\n",
    "            \n",
    "            next_state_np, reward, terminated, truncated, _ = env_instance.step(action_clipped)\n",
    "            done = terminated or truncated\n",
    "            state = torch.from_numpy(next_state_np).float().to(device)\n",
    "            episode_reward += reward\n",
    "            t += 1\n",
    "        \n",
    "        print(f\"Test Episode {i+1}: Reward = {episode_reward:.2f}, Length = {t}\")\n",
    "        all_rewards.append(episode_reward)\n",
    "        if render:\n",
    "             env_instance.close() # Close the render window\n",
    "\n",
    "    print(f\"--- Testing Complete. Average Reward: {np.mean(all_rewards):.2f} ---\")\n",
    "\n",
    "# Run test episodes (ensure env is still available)\n",
    "test_ddpg_agent(actor_ddpg, env, num_episodes=3, render=False) # Set render=True if you have display setup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Common Challenges and Solutions in DDPG\n",
    "\n",
    "**Challenge: Sensitivity to Hyperparameters**\n",
    "*   **Problem:** DDPG is known to be quite sensitive to learning rates, target update rate ($\tau$), noise parameters, network architecture, and batch size.\n",
    "   **Solutions**:\n",
    "    *   **Careful Tuning:** Start with known good values for the environment and tune systematically.\n",
    "    *   **Smaller $\\tau$:** Slower target updates (smaller $\\tau$) often increase stability.\n",
    "    *   **Separate Learning Rates:** Using different (often lower for actor) learning rates for actor and critic can be beneficial.\n",
    "    *   **Batch Normalization:** Can sometimes help stabilize learning in network layers.\n",
    "\n",
    "**Challenge: Q-Value Overestimation**\n",
    "*   **Problem:** The critic can learn to overestimate Q-values, especially when using function approximation. This can lead to the actor learning a suboptimal policy that exploits these overestimations.\n",
    "   **Solutions**:\n",
    "    *   **TD3 (Twin Delayed DDPG):** A direct successor that addresses this using clipped double Q-learning (two critics, minimum target), delayed policy updates, and target policy smoothing.\n",
    "    * **Target Network Usage:** Target networks already help mitigate this to some extent compared to not using them.\n",
    "\n",
    "**Challenge: Exploration in Continuous Spaces**\n",
    "*   **Problem:** Simple noise like Gaussian might not be sufficient for exploring complex state-action spaces effectively.\n",
    "   **Solutions**:\n",
    "    *   **Correlated Noise (Ornstein-Uhlenbeck):** Used in the original DDPG paper, encourages more consistent exploration trajectories.\n",
    "    *   **Parameter Space Noise:** Adds noise directly to the actor's parameters instead of actions, potentially leading to more consistent exploration.\n",
    "    *   **Adaptive Noise:** Adjust noise scale based on performance or distance between actor and target actor parameters.\n",
    "\n",
    "**Challenge: Slow Learning on Complex Tasks**\n",
    "*   **Problem:** While sample efficient due to off-policy learning, convergence can still be slow on very hard problems.\n",
    "   **Solutions**:\n",
    "    *   **Prioritized Experience Replay (PER):** Sample important transitions more often from the replay buffer.\n",
    "    *   **TD3/SAC:** Successor algorithms often learn faster and more robustly.\n",
    "    * **Distributed DDPG (e.g., Ape-X DDPG):** Use multiple actors to collect experience in parallel feeding a central learner.\n",
    "\n",
    "## Conclusion\n",
    "\n",
    "Deep Deterministic Policy Gradient (DDPG) successfully extends actor-critic methods to continuous action spaces by learning a deterministic policy and leveraging techniques from DQN like replay buffers and target networks for stable, off-policy learning. Its ability to handle continuous actions made it a foundational algorithm for robotics and continuous control tasks.\n",
    "\n",
    "While DDPG can be sensitive to hyperparameters and sometimes prone to Q-value overestimation, its core concepts—off-policy actor-critic learning with deterministic policies and target networks—paved the way for more advanced and robust algorithms like TD3 and SAC. Understanding DDPG is essential for tackling continuous control problems in reinforcement learning."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv-all-rl-algos",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
